/**
 * 转换字符串的字符集编码
 * @param str 需要转换的字符串
 * @param charset 字符集编码
 */
export function decodeStringToCharset(str: string, charset = 'UTF-8') {
  const encoder = new TextEncoder();
  const decoder = new TextDecoder(charset);
  return decoder.decode(encoder.encode(str));
}

export function jsonToColonFormat(jsonObj) {
  if (typeof jsonObj !== 'object' || jsonObj === null) {
    throw new Error('Input must be a JSON object');
  }

  let result = '';

  // 遍历对象的第一层属性
  for (const key in jsonObj) {
    if (jsonObj.hasOwnProperty(key)) {
      const value = jsonObj[key];

      // 定义一个函数来生成不带双引号的 JSON 字符串
      function stringifyWithoutQuotes(obj) {
        if (obj === null) {
          return 'null';
        }
        if (typeof obj === 'object' && obj !== null) {
          if (Array.isArray(obj)) {
            return `[${obj.map(item => stringifyWithoutQuotes(item)).join(',')}]`;
          } else {
            const properties = [];
            for (const k in obj) {
              if (obj.hasOwnProperty(k)) {
                const v = obj[k];
                properties.push(`${k}:${stringifyWithoutQuotes(v)}`);
              }
            }
            return `{${properties.join(',')}}`;
          }
        } else if (typeof obj === 'string') {
          return JSON.stringify(obj); // 对字符串进行转义
        } else {
          return obj.toString();
        }
      }

      // 如果值是对象或数组，使用自定义函数生成字符串
      if (typeof value === 'object' && value !== null) {
        result += `${key}:${stringifyWithoutQuotes(value)}\n`;
      } else {
        // 处理基本数据类型
        if (typeof value === 'string') {
          // 对字符串进行转义，确保输出的字符串是安全的
          result += `${key}:${JSON.stringify(value)}\n`;
        } else if (typeof value === 'number' || typeof value === 'boolean' || value === null) {
          // 直接输出数字、布尔值和 null
          result += `${key}:${value}\n`;
        }
      }
    }
  }

  return result.trim();
}

export function colonFormatToJson(str) {
  const result = {};

  // 使用换行符分割字符串以提取键值对
  const keyValuePairs = str.split('\n');

  // 遍历所有的键值对
  keyValuePairs.forEach(pair => {
    // 去除空白字符
    pair = pair.trim();

    // 如果键值对为空，则跳过
    if (!pair) {
      return;
    }

    // 提取键和值
    const parts = pair.split(':').map(part => part.trim());
    const key = parts[0]; // 原始键
    const rawValue = parts.slice(1).join(':').trim(); // 重新组合可能带有冒号的值

    // 尝试将值转换为正确的数据类型
    const value = parseJsonValue(rawValue);

    // 将键值对添加到结果对象中
    result[key] = value;
  });

  return result;
}

function parseJsonValue(valueStr) {
  if (valueStr.startsWith('{') && valueStr.endsWith('}')) {
    return parseJsonObject(valueStr);
  } else if (valueStr.startsWith('[') && valueStr.endsWith(']')) {
    return parseJsonArray(valueStr);
  } else if (valueStr === 'true' || valueStr === 'false') {
    return valueStr === 'true';
  } else if (valueStr === 'null') {
    return null;
  } else if (!isNaN(Number(valueStr))) {
    return Number(valueStr);
  } else if (valueStr.startsWith('"') && valueStr.endsWith('"') ||
    valueStr.startsWith("'") && valueStr.endsWith("'") ||
    valueStr.startsWith("`") && valueStr.endsWith("`")) {
    return valueStr.slice(1, -1);
  } else {
    return valueStr; // 确保字符串有引号
  }
}

function parseJsonObject(jsonStr) {
  const result = {};
  const content = jsonStr.slice(1, -1).trim();

  if (!content) {
    return result;
  }

  const pairs = content.split(',');
  pairs.forEach(pair => {
    const parts = pair.split(':').map(part => part.trim());
    const key = parts[0]; // 原始键
    const rawValue = parts.slice(1).join(':').trim();
    const value = parseJsonValue(rawValue);

    result[key] = value;
  });

  return result;
}

function parseJsonArray(jsonStr) {
  // 将所有未加引号的键转换为带双引号的形式
  const strWithQuotes = jsonStr.replace(/(\w+):/g, '"$1":');

  try {
    // 使用 JSON.parse 安全地解析 JSON 字符串
    const result = JSON.parse(strWithQuotes);

    // 确保返回的是一个数组
    if (Array.isArray(result)) {
      return result;
    } else {
      throw new Error("Provided JSON string is not an array.");
    }
  } catch (error) {
    // 如果 JSON 解析出错，抛出错误或者返回空数组
    console.error('Failed to parse JSON array:', error);
    return [];
  }
}

/**
 * json转为表格
 * */
function isInteger(n) {
  return Number.isInteger(n);
}

export function JsonforData(jsonObj) {
  const data = { root: {} }
  data.root = jsonObj
  jsonObj = data
  return jsonToTableData1(data)
}

export function jsonToTableData1(jsonObj) {
  return Object.entries(jsonObj).map(([key, value]) => {
    const keyType = typeof value;
    let typeStr = '';
    if (keyType == 'object') {
      typeStr = 'object';
      let children = []
      if (JSON.stringify(value) === '{}' || value === null) {
        value = ''
      } else {
        children = jsonToTableData1(value)
        value = ''
      }
      value = ''
      return {
        id: guid(),
        keyName: key,
        keyValue: value,
        keyType: typeStr,
        children: children
      };
    } else {
      if (keyType === 'number') {
        typeStr = isInteger(value) ? 'integer' : 'number';
      } else if (keyType === 'boolean') {
        typeStr = 'boolean';
      } else if (keyType === 'string') {
        typeStr = 'string';
      } else {
        typeStr = keyType; // 其他类型保持原样
      }
      return {
        id: guid(),
        keyName: key,
        keyValue: value,
        keyType: typeStr,
      };
    }
  });
}
export function jsonToTableData(jsonObj) {
  return Object.entries(jsonObj).map(([key, value]) => {
    let keyValue = value;
    let typeStr = '';

    if (Array.isArray(value)) {
      // 如果值是数组，则将其转换为 JSON 字符串
      keyValue = JSON.stringify(value, null, 2); // 使用缩进使 JSON 更易读
      typeStr = 'array';
    } else if (typeof value === 'object' && value !== null) {
      // 如果值是对象且不是 null，则将其转换为 JSON 字符串
      keyValue = JSON.stringify(value, null, 2); // 使用缩进使 JSON 更易读
      typeStr = 'object';
    } else {
      // 其他基本类型
      if (typeof value === 'number') {
        typeStr = isInteger(value) ? 'integer' : 'number';
      } else if (typeof value === 'boolean') {
        typeStr = 'boolean';
      } else if (typeof value === 'string') {
        typeStr = 'string';
      } else {
        typeStr = typeof value; // 其他类型保持原样
      }
    }

    return {
      id: guid(),
      keyName: key,
      keyValue: keyValue,
      keyType: typeStr,
    };
  });
}

export const guid = () => {
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(
    /[xy]/g,
    function (c) {
      const r = (Math.random() * 16) | 0,
        v = c == 'x' ? r : (r & 0x3) | 0x8
      return v.toString(16)
    }
  )
}

export function DataforJson(tableData) {
  if (tableData) {
    if (tableData[0].keyName == "root") {
      if (tableData[0].children) {
        tableData = tableData[0].children
      } else {
        tableData = []
      }
    }
  }
  else {
    tableData = []
  }
  return tableDataToJson1(tableData)
}
export function tableDataToJson1(tableData) {
  return tableData.reduce((acc, { keyName, keyValue, keyType, children }) => {
    let value;
    if (keyType == 'array') {
      value = []
      if (children) {
        children.forEach((item) => {
          if (item.children) {
            const child = tableDataToJson1(item.children)
            value.push(child)
          } else {
            value.push(item.keyValue)
          }
        })
      } else {
        value = []
      }
      acc[keyName] = value;
    } else {
      if (keyType == 'boolean') {
        value = !!keyValue
      } else if (keyType == 'number' || keyType == 'integer') {
        value = keyValue * 1
      } else if (keyType == 'object') {
        if (children) {
          const child = tableDataToJson1(children)
          value = { ...child }
        } else {
          value = {}
        }
      } else {
        value = keyValue
      }
      acc[keyName] = value;
    }
    return acc;
  }, {});
}
/**
 * 表格数据转为json
 * */
export function tableDataToJson(tableData) {
  return tableData.reduce((acc, { keyName, keyValue, keyType, children }) => {
    if (!keyName) {
      // 如果 keyName 为空，则跳过该条目
      return acc;
    }

    let value;

    if (keyType === 'array') {
      if (Array.isArray(keyValue)) {
        // 如果 keyValue 已经是数组，则直接使用
        value = keyValue;
      } else {
        try {
          value = keyValue ? JSON.parse(keyValue) : []; // 尝试将字符串解析为数组
          if (!Array.isArray(value)) {
            console.error(`Parsed value is not an array: ${keyValue}`);
            value = []; // 如果解析结果不是数组，则设置为空数组
          }
        } catch (e) {
          console.error(`Failed to parse array string: ${keyValue}`, e);
          value = []; // 如果解析失败，则设置为空数组
        }
      }
    } else if (keyType === 'boolean') {
      value = keyValue ? keyValue.toLowerCase() === 'true' : false; // 将字符串 'true' 或 'false' 转换为布尔值
    } else if (keyType === 'number' || keyType === 'integer') {
      value = Number(keyValue); // 将字符串转换为数字
    } else if (keyType === 'object' || isJsonString(keyValue)) {
      try {
        value = keyValue ? JSON.parse(keyValue) : {}; // 尝试将字符串解析为对象
      } catch (e) {
        console.error(`Failed to parse object or array string: ${keyValue}`, e);
        value = {}; // 如果解析失败，则设置为空对象
      }
    } else {
      value = keyValue; // 其他类型保持原样
    }

    acc[keyName] = value;
    return acc;
  }, {});
}
// 辅助函数：检查一个字符串是否是有效的 JSON
function isJsonString(str) {
  try {
    const parsed = JSON.parse(str);
    return (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) || Array.isArray(parsed);
  } catch (e) {
    return false;
  }
}
export function evnjsonToTableData(jsonObj) {
  return Object.entries(jsonObj).map(([key, value]) => {
    return {
      varName: key,
      localValue: value
    };
  });
}

export function evntableDataToJson(tableData) {
  return tableData.reduce((acc, { varName, localValue }) => {
    acc[varName] = localValue;
    return acc;
  }, {});
}

export function formatSwaggerToRequests(swaggerData) {
  const isOAS3 = swaggerData.openapi?.startsWith('3');

  return Object.entries(swaggerData.paths).flatMap(([path, methods]) => 
    Object.entries(methods).map(([method, endpoint]) => {
      // 处理所有参数类型
      const params = (endpoint.parameters || []).concat(swaggerData.parameters || [])
        .reduce((acc, param) => {
          const paramType = param.in === 'header' ? 'headers' : 
                          param.in === 'path' ? 'pathParams' : 
                          param.in === 'query' ? 'queryParams' : 
                          null;

          if (paramType) {
            acc[paramType].push({
              name: param.name,
              required: param.required || false,
              example: getParamExample(param, isOAS3),
              description: param.description || ''
            });
          }
          return acc;
        }, {
          headers: [],
          pathParams: [],
          queryParams: []
        });

      // 生成body
      const body = generateBody(
        isOAS3 ? endpoint.requestBody : 
        endpoint.parameters?.find(p => p.in === 'body')
      );

      return {
        title: endpoint.summary || path,
        method: method.toUpperCase(),
        path: path.replace(/{/g, ':').replace(/}/g, ''),
        parameters: {
          ...params,
          body: body
        }
      };
    })
  );
}

function generateBody(bodyDef) {
  if (!bodyDef) return null;

  // OpenAPI 3.0处理
  if (bodyDef.content) {
    const schema = bodyDef.content['application/json']?.schema;
    return schema ? generateExample(schema) : null;
  }

  // Swagger 2.0处理
  if (bodyDef.schema) {
    return generateExample(bodyDef.schema);
  }

  return null;
}

function generateExample(schema) {
  if (!schema) return null;

  const example = schema.example || {};
  
  if (schema.properties) {
    Object.entries(schema.properties).forEach(([key, prop]) => {
      if (!example[key]) {
        example[key] = prop.example || getTypeExample(prop);
        
        // 处理嵌套对象
        if (prop.type === 'object' && prop.properties) {
          example[key] = generateExample(prop);
        }
        
        // 处理数组
        if (prop.type === 'array' && prop.items) {
          example[key] = [generateExample(prop.items)];
        }
      }
    });
  }
  
  return example;
}

function getParamExample(param, isOAS3) {
  return param.example || 
    (isOAS3 && param.schema?.example) || 
    param.schema?.enum?.[0] || 
    getTypeExample(isOAS3 ? param.schema : param);
}

function getTypeExample(prop) {
  const typeMap = {
    string: prop?.enum?.[0] || (prop?.format === 'date-time' ? new Date().toISOString() : 'string'),
    number: prop?.minimum || 0,
    integer: prop?.minimum || 0,
    boolean: true,
    object: {},
    array: []
  };
  return typeMap[prop?.type] ?? 'unknown';
}